#import "Frame.h"
#import <math.h>


Frame::Frame() 
{  
	memset(this, 0, sizeof (Frame));
}

Frame::Frame(const Frame& rf)
{
	m_iOffX = rf.m_iOffX; //∏”¥V™∫∞æ≤æ
    m_iOffY = rf.m_iOffY;
    m_Num = rf.m_Num; //√∏ªs™∫¶∏º∆
    imgID = new byte[m_Num];
    m_iX = new int[m_Num];
    m_iY = new int[m_Num];
    m_iClipX = new int[m_Num];
    m_iClipY = new int[m_Num];
    m_iClipW = new int[m_Num];
    m_iClipH = new int[m_Num];
    m_filp=  new byte[m_Num];
    for (int i = 0; i < m_Num; i++) {
		imgID[i] = rf.imgID[i]; //πœ§˘ID
		m_iX[i] = rf.m_iX[i]; //√∏ªs¶Ï∏m
		m_iY[i] = rf.m_iY[i];
		m_iClipX[i] = rf.m_iClipX[i]; //∏Í∑Ωπœ™∫≠˛≥°§¿
		m_iClipY[i] = rf.m_iClipY[i];
		m_iClipW[i] = rf.m_iClipW[i];
		m_iClipH[i] = rf.m_iClipH[i];
		m_filp[i] = rf.m_filp[i];
    }
	
    m_bCollisionRectNum = rf.m_bCollisionRectNum;
	
	m_iColRectX = new int[m_bCollisionRectNum];
	m_iColRectY = new int[m_bCollisionRectNum];
	m_iColRectW = new int[m_bCollisionRectNum];
	m_iColRectH = new int[m_bCollisionRectNum];
	
	
	for (int i = 0; i < m_bCollisionRectNum; i++) {
		m_iColRectX[i] = rf.m_iColRectX[i];
		m_iColRectY[i] = rf.m_iColRectY[i];
		m_iColRectW[i] = rf. m_iColRectW[i];
		m_iColRectH[i] = rf.m_iColRectH[i];
		
	}
	m_HitRectNum = rf.m_HitRectNum;
	if(m_HitRectNum>0){
		m_ihitX = new int[m_HitRectNum];
		m_ihitY = new int[m_HitRectNum];
		m_ihitW = new int[m_HitRectNum];
		m_ihitH = new int[m_HitRectNum];
	}
	
	for (int i = 0; i < m_HitRectNum; i++) {
		m_ihitX[i] = rf.m_ihitX[i];
		m_ihitY[i] = rf.m_ihitY[i];
		m_ihitW[i] = rf.m_ihitW[i];
		m_ihitH[i] = rf.m_ihitH[i];
		
	}
	m_BHitRectNum = rf.m_BHitRectNum;
	if(m_BHitRectNum>0){
		m_ibHiitX = rf.m_ibHiitX;
		m_ibHitY = rf.m_ibHitY;
		m_ibHitW = rf.m_ibHitW;
		m_ibHitH = rf.m_ibHitH;
	}
	
	for (int i = 0; i < m_BHitRectNum; i++) {
		m_ibHiitX[i] = rf. m_ibHiitX[i];
		m_ibHitY[i] = rf.m_ibHitY[i];
		m_ibHitW[i] = rf. m_ibHitW[i] ;
		m_ibHitH[i] = rf.m_ibHitH[i];
	}
	
}

Frame::~Frame()
{
	SAFE_DELETE(imgID);//πœ§˘ID
	SAFE_DELETE(m_iX);//√∏ªs¶Ï∏m
	SAFE_DELETE(m_iY);
	SAFE_DELETE(m_iClipX);//∏Í∑Ωπœ™∫≠˛≥°§¿
	SAFE_DELETE(m_iClipY);
	SAFE_DELETE(m_iClipW);
	SAFE_DELETE(m_iClipH);
	SAFE_DELETE(m_filp);
	SAFE_DELETE(m_iColRectX);//
	SAFE_DELETE(m_iColRectY);
	SAFE_DELETE(m_iColRectW);
	SAFE_DELETE(m_iColRectH);
	SAFE_DELETE(m_ihitX);//
	SAFE_DELETE(m_ihitY);
	SAFE_DELETE(m_ihitW);
	SAFE_DELETE(m_ihitH);
	SAFE_DELETE(m_ibHiitX);//
	SAFE_DELETE(m_ibHitY);
	SAFE_DELETE(m_ibHitW);
	SAFE_DELETE(m_ibHitH);
}

//void Frame::drawChangeColorFrame(Graphics g,int x,int y,int type,int off){
//     tType=off;
//     g.setClip(0, 0, Data.WIDTH,Data.HEIGHT);
//	
//	for (int i = 0; i < m_Num; i++) {
//      int _x = x + m_iOffX + m_iX[i];
//      int _y = y + m_iOffY + m_iY[i];
//      int[] argb = new int[m_iClipW[i] * m_iClipH[i]];
//       if(tType==0){
//           Map.allImg[imgID[i]].getRGB(argb, 0,
//                                       m_iClipW[i],
//                                       m_iClipX[i], m_iClipY[i],
//                                       m_iClipW[i],
//                                       m_iClipH[i]); //¿Ú±oπœ§˘™∫ARGB≠»
//       }else{
//         Image img=null;
//            img = Image.createImage(Map.allImg[imgID[i]], m_iClipX[i], m_iClipY[i],
//                                    m_iClipW[i],
//                                    m_iClipH[i], Graphics.VCENTER
//                                    );
//                img.getRGB(argb, 0, m_iClipW[i],
//                                          0,0,
//                                          m_iClipW[i],
//                                          m_iClipH[i]); //¿Ú±oπœ§˘™∫ARGB≠»
//
//
//       }
//      for (int c = 0; c < argb.length; c++) {
//        int r = (argb[c] & 0x00FF0000) >> 16; //¿Ú±ored≠»
//        int gg = (argb[c] & 0x0000ff00) >> 8; //¿Ú±ogreen≠»
//        int b = argb[c] & 0x000000ff; //¿Ú±oblue≠»
//         if (true) { //ΩM
//           r += 80;
//          if (r >= 255) {
//            r = 255;
//          }
//          gg += 80;
//          if (gg >= 255) {
//            gg = 255;
//          }
//          b += 80;
//          if (b >= 255) {
//            b = 255;
//          }
//           r <<= 16;
//           gg <<= 8;
//         }
//        argb[c] = argb[c] | r | gg | b; // ≠◊ßÔ ™∫≠»
//      }
//      if(tType==0){
//        g.drawRGB(argb, 0, m_iClipW[i], _x, _y,
//                  m_iClipW[i],
//                  m_iClipH[i], true); // µeπ≥Ø¿º∆≤’
//      }else{
//        g.drawRGB(argb, 0, m_iClipW[i], x-(m_iX[i]+  m_iClipW[i]), _y,
//                m_iClipW[i],
//                m_iClipH[i], true); // µeπ≥Ø¿º∆≤’
//
//      }
//    }
//  }


void Frame::loadFrame(FILE* fp){
	fread( &m_Num, sizeof(byte), 1, fp);
    
	fread( &m_iOffX, sizeof(int), 1, fp);
	JavaBitReverse(&m_iOffX, sizeof(int), 1);
	
	fread( &m_iOffY, sizeof(int), 1, fp);
	JavaBitReverse(&m_iOffY, sizeof(int), 1);

	imgID  = new byte[m_Num];
	m_iX  =  new int[m_Num];
	m_iY  =  new int[m_Num];
	m_iClipX  =  new int[m_Num];
	m_iClipY  =  new int[m_Num];
	m_iClipW  = new int[m_Num];
	m_iClipH  =  new int[m_Num];
	m_filp  =  new byte[m_Num];
	
	for (int i = 0; i < m_Num; i++) {
		fread( &imgID[i], sizeof(byte), 1, fp);

		fread( &m_iX[i], sizeof(int), 1, fp);
		JavaBitReverse(&m_iX[i], sizeof(int), 1);

		fread( &m_iY[i], sizeof(int), 1, fp);
		JavaBitReverse(&m_iY[i], sizeof(int), 1);

		fread( &m_iClipX[i], sizeof(int), 1, fp);
		JavaBitReverse(&m_iClipX[i], sizeof(int), 1);

		fread( &m_iClipY[i], sizeof(int), 1, fp);
		JavaBitReverse(&m_iClipY[i], sizeof(int), 1);

		fread( &m_iClipW[i], sizeof(int), 1, fp);
		JavaBitReverse(&m_iClipW[i], sizeof(int), 1);

		fread( &m_iClipH[i], sizeof(int), 1, fp);
		JavaBitReverse(&m_iClipH[i], sizeof(int), 1);

		fread( &m_filp[i], sizeof(byte), 1, fp);
	}

	fread( &m_bCollisionRectNum, sizeof(byte), 1, fp);
	
      if(m_bCollisionRectNum>0){
        m_iColRectX = new int[m_bCollisionRectNum];
        m_iColRectY = new int[m_bCollisionRectNum];
        m_iColRectW = new int[m_bCollisionRectNum];
        m_iColRectH = new int[m_bCollisionRectNum];
      }

     for (int i = 0; i < m_bCollisionRectNum; i++) {
		 fread( &m_iColRectX[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_iColRectX[i], sizeof(int), 1);
		 
		 fread( &m_iColRectY[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_iColRectY[i], sizeof(int), 1);
		 
		 fread( &m_iColRectW[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_iColRectW[i], sizeof(int), 1);
		 
		 fread( &m_iColRectH[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_iColRectH[i], sizeof(int), 1);
     }

	fread( &m_HitRectNum, sizeof(byte), 1, fp);
     if(m_HitRectNum>0){
		m_ihitX = new int[m_HitRectNum];
		m_ihitY = new int[m_HitRectNum];
		m_ihitW = new int[m_HitRectNum];
		m_ihitH = new int[m_HitRectNum];
     }

     for (int i = 0; i < m_HitRectNum; i++) {
		 fread( &m_ihitX[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_ihitX[i], sizeof(int), 1);
		 
		 fread( &m_ihitY[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_ihitY[i], sizeof(int), 1);
		 
		 fread( &m_ihitW[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_ihitW[i], sizeof(int), 1);
		 
		 fread( &m_ihitH[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_ihitH[i], sizeof(int), 1);
     }

	fread( &m_BHitRectNum, sizeof(byte), 1, fp);
	
     if(m_BHitRectNum>0){
       m_ibHiitX = new int[m_BHitRectNum];
       m_ibHitY = new int[m_BHitRectNum];
       m_ibHitW = new int[m_BHitRectNum];
       m_ibHitH = new int[m_BHitRectNum];
     }

     for (int i = 0; i < m_BHitRectNum; i++) {
		 fread( &m_ibHiitX[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_ibHiitX[i], sizeof(int), 1);
		 
		 fread( &m_ibHitY[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_ibHitY[i], sizeof(int), 1);
		 
		 fread( &m_ibHitW[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_ibHitW[i], sizeof(int), 1);
		 
		 fread( &m_ibHitH[i], sizeof(int), 1, fp);
		 JavaBitReverse(&m_ibHitH[i], sizeof(int), 1);
     }
    
	//int time= in.readShort();
	m_iTime = 0;
	fread(&m_iTime, sizeof (short), 1, fp);
	 JavaBitReverse(&m_iTime, sizeof(m_iTime), 1);
 }

